package platzerworld.kegeln.gui.utilities;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.List;

import platzerworld.kegeln.R;
import platzerworld.kegeln.common.ConstantsIF;
import platzerworld.kegeln.common.appengine.RemoteActivity;
import platzerworld.kegeln.common.logging.LOG;
import platzerworld.kegeln.common.map.ShowMap;
import platzerworld.kegeln.db.KegelverwaltungCSVDatenbank;
import platzerworld.kegeln.db.KegelverwaltungDatenbank;
import platzerworld.kegeln.db.ergebnis.ErgebnisSpeicher;
import platzerworld.kegeln.db.klasse.KlasseSpeicher;
import platzerworld.kegeln.db.mannschaft.MannschaftSpeicher;
import platzerworld.kegeln.db.spieler.SpielerSpeicher;
import platzerworld.kegeln.db.verein.VereinSpeicher;
import platzerworld.kegeln.db.wettkampf.WettkampfSpeicher;
import platzerworld.kegeln.gui.chart.KegelverwaltungChart;
import platzerworld.kegeln.gui.kegelauswahl.AuswahlKegel;
import platzerworld.kegeln.gui.tabs.CustomTabActivity;
import android.app.Activity;
import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.hardware.SensorListener;
import android.hardware.SensorManager;
import android.location.Criteria;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.media.AudioManager;
import android.net.wifi.WifiManager;
import android.os.Bundle;
import android.os.Environment;
import android.os.Vibrator;
import android.telephony.SmsManager;
import android.util.Log;
import android.view.Display;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.WindowManager;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;
import au.com.bytecode.opencsv.CSVWriter;

public class UtilitiesActivity extends Activity implements ConstantsIF{
	private static final String TAG = UtilitiesActivity.class.getSimpleName();

	private static final long MIN_LOCATION_UPDATE_TIME = 36000;

	private static final float MIN_LOCATION_UPDATE_DISTANCE = 500;
	
	private LocationManager mLocationManager;;
	
	private EditText input = null;

	private AudioManager mAudio;
	
	private KlasseSpeicher mKlasseSpeicher;
	private MannschaftSpeicher mMannschaftSpeicher;
	private SpielerSpeicher mSpielerSpeicher;
	private ErgebnisSpeicher mErgebnisSpeicher;
	private VereinSpeicher mVereinSpeicher;
	private WettkampfSpeicher mWettkampfSpeicher;
	
	/**
	 * @see android.app.Activity#onCreate(Bundle)
	 */
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.utilities);
		Button mapButton = (Button) findViewById(R.id.mapViewButton);
		mapButton.setOnClickListener(mMapsListener);
		
		Button reseDBButton = (Button) findViewById(R.id.resetDB);
		reseDBButton.setOnClickListener(mResetDBListener);
		
		Button auswahlKegelButton = (Button) findViewById(R.id.auswahlkegel);
		auswahlKegelButton.setOnClickListener(mAuswahlKegelListener);
		
		//Button deleteTableButton = (Button) findViewById(R.id.deleteTable);
		//deleteTableButton.setOnClickListener(mDeleteTableListener);
		
		//Button createTableButton = (Button) findViewById(R.id.createTable);
		//createTableButton.setOnClickListener(mCreateTableListener);
		
		Button deleteDataButton = (Button) findViewById(R.id.deleteData);
		deleteDataButton.setOnClickListener(mDeleteDataListener);
		
		//Button insertDataButton = (Button) findViewById(R.id.InsertData);
		//insertDataButton.setOnClickListener(mInsertDataListener);
		
		Button chartButton = (Button) findViewById(R.id.Chart);
		chartButton.setOnClickListener(mChartListener);
		
		Button tabsButton = (Button) findViewById(R.id.tabhost);
		tabsButton.setOnClickListener(mTabsListener);
		
		Button displayButton = (Button) findViewById(R.id.Display);
		displayButton.setOnClickListener(mDisplayListener);
		
		Button remoteButton = (Button) findViewById(R.id.Remote);
		remoteButton.setOnClickListener(mRemoteListener);
		
		Button exportCSVButton = (Button) findViewById(R.id.exportCSV);
		exportCSVButton.setOnClickListener(mExportCSVListener);
		
		Button importCSVButton = (Button) findViewById(R.id.importCSV);
		importCSVButton.setOnClickListener(mImportCSVListener);
		
	}
	
	/**
	 * Bis Android 1.6: Listener für Klick-Event auf Schaltfläche 'Karte
	 * Anzeigen'.
	 */
	private final OnClickListener mMapsListener = new OnClickListener() {
		public void onClick(View v) {
			final Intent settingsActivity = new Intent(UtilitiesActivity.this, ShowMap.class);
			startActivity(settingsActivity);
		}
	};
	
	/**
	 * Bis Android 1.6: Listener für Klick-Event auf Schaltfläche 'Karte
	 * Anzeigen'.
	 */
	private final OnClickListener mResetDBListener = new OnClickListener() {
		public void onClick(View v) {
			KegelverwaltungDatenbank db = new KegelverwaltungDatenbank(UtilitiesActivity.this);
			db.resetDB();
			
			finishDB();
		}
	};
	
	/**
	 * Bis Android 1.6: Listener für Klick-Event auf Schaltfläche 'Karte
	 * Anzeigen'.
	 */
	private final OnClickListener mAuswahlKegelListener = new OnClickListener() {
		public void onClick(View v) {
			final Intent sensorActivity = new Intent(UtilitiesActivity.this, AuswahlKegel.class);
			startActivity(sensorActivity);
		}
	};
	
	/**
	 * Bis Android 1.6: Listener für Klick-Event auf Schaltfläche 'Karte
	 * Anzeigen'.
	 */
	private final OnClickListener mDeleteTableListener = new OnClickListener() {
		public void onClick(View v) {
			KegelverwaltungDatenbank db = new KegelverwaltungDatenbank(UtilitiesActivity.this);
			db.deleteTable();
			
		}
	};
	
	/**
	 * Bis Android 1.6: Listener für Klick-Event auf Schaltfläche 'Karte
	 * Anzeigen'.
	 */
	private final OnClickListener mCreateTableListener = new OnClickListener() {
		public void onClick(View v) {
			KegelverwaltungDatenbank db = new KegelverwaltungDatenbank(UtilitiesActivity.this);
			db.createTable();
			
		}
	};
	
	/**
	 * Bis Android 1.6: Listener für Klick-Event auf Schaltfläche 'Karte
	 * Anzeigen'.
	 */
	private final OnClickListener mDeleteDataListener = new OnClickListener() {
		public void onClick(View v) {
			KegelverwaltungDatenbank db = new KegelverwaltungDatenbank(UtilitiesActivity.this);
			db.deleteData();
			
			finishDB();
			
		}
	};
	
	/**
	 * Bis Android 1.6: Listener für Klick-Event auf Schaltfläche 'Karte
	 * Anzeigen'.
	 */
	private final OnClickListener mInsertDataListener = new OnClickListener() {
		public void onClick(View v) {
			KegelverwaltungDatenbank db = new KegelverwaltungDatenbank(UtilitiesActivity.this);
			db.resetAutoincrements();
			db.insertData();
			
		}
	};
	
	/**
	 * Bis Android 1.6: Listener für Klick-Event auf Schaltfläche 'Karte
	 * Anzeigen'.
	 */
	private final OnClickListener mChartListener = new OnClickListener() {
		public void onClick(View v) {
			final Intent sensorActivity = new Intent(UtilitiesActivity.this, KegelverwaltungChart.class);
			startActivity(sensorActivity);
		}
	};
	
	/**
	 * Bis Android 1.6: Listener für Klick-Event auf Schaltfläche 'Karte
	 * Anzeigen'.
	 */
	private final OnClickListener mTabsListener = new OnClickListener() {
		public void onClick(View v) {
			final Intent sensorActivity = new Intent(UtilitiesActivity.this, CustomTabActivity.class);
			startActivity(sensorActivity);
		}
	};
	
	/**
	 * Bis Android 1.6: Listener für Klick-Event auf Schaltfläche 'Karte
	 * Anzeigen'.
	 */
	private final OnClickListener mDisplayListener = new OnClickListener() {
		public void onClick(View v) {
			showDisplayProperties();
		}
	};
	
	/**
	 * Bis Android 1.6: Listener für Klick-Event auf Schaltfläche 'Karte
	 * Anzeigen'.
	 */
	private final OnClickListener mRemoteListener = new OnClickListener() {
		public void onClick(View v) {
			final Intent remoteActivity = new Intent(UtilitiesActivity.this, RemoteActivity.class);
			startActivity(remoteActivity);
		}
	};
	
	/**
	 * Bis Android 1.6: Listener für Klick-Event auf Schaltfläche 'Karte
	 * Anzeigen'.
	 */
	private final OnClickListener mExportCSVListener = new OnClickListener() {
		public void onClick(View v) {
			exportCSV();
		}
	};
	
	private void exportCSV(){
		mKlasseSpeicher = new KlasseSpeicher(this);
		mMannschaftSpeicher = new MannschaftSpeicher(this);
		mSpielerSpeicher = new SpielerSpeicher(this);
		mErgebnisSpeicher = new ErgebnisSpeicher(this);
		mVereinSpeicher = new VereinSpeicher(this);
		mWettkampfSpeicher = new WettkampfSpeicher(this);
		

		List<String[]> klassenList = mKlasseSpeicher.ladeKlassenAsStringArray();
		List<String[]> mannschaftList = mMannschaftSpeicher.ladeMannschaftAsStringArray();
		List<String[]> spielerList = mSpielerSpeicher.ladeSpielerAsStringArray();
		List<String[]> ergebnisList = mErgebnisSpeicher.ladeErgebnisAsStringArray();
		List<String[]> vereinList = mVereinSpeicher.ladeVereinAsStringArray();
		List<String[]> wettkampfList = mWettkampfSpeicher.ladeWettkampfAsStringArray();
		
		Environment.getExternalStorageDirectory();
		Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);
		
		try {
		    File root = Environment.getExternalStorageDirectory();
		    if (root.canWrite()){
		    	File dir = new File(root, "kegeln");
		    	dir.mkdir();
		    	
		    	File klassenFile = new File(dir, "klassen.csv");
		    	File mannschaftFile = new File(dir, "mannschaften.csv");
		    	File spielerFile = new File(dir, "spieler.csv");
		    	File ergebnisFile = new File(dir, "ergebnis.csv");
		    	File vereinFile = new File(dir, "verein.csv");
		    	File wettkampfFile = new File(dir, "wettkampf.csv");
		    	
		    	CSVWriter writer = new CSVWriter(new FileWriter(klassenFile), '#');
			     // feed in your array (or convert your data to an array)
		    	
		    	for (String[] zeile : klassenList) {
		    		writer.writeNext(zeile);
				}
				 writer.close();
				 
				 CSVWriter mannschaftWriter = new CSVWriter(new FileWriter(mannschaftFile), '#');
			     // feed in your array (or convert your data to an array)
		    	
		    	for (String[] zeile : mannschaftList) {
		    		mannschaftWriter.writeNext(zeile);
				}
		    	mannschaftWriter.close();
		    	
		    	CSVWriter spielerWriter = new CSVWriter(new FileWriter(spielerFile), '#');
			     // feed in your array (or convert your data to an array)
		    	
		    	for (String[] zeile : spielerList) {
		    		spielerWriter.writeNext(zeile);
				}
		    	spielerWriter.close();
		    	
		    	CSVWriter ergebnisWriter = new CSVWriter(new FileWriter(ergebnisFile), '#');
			     // feed in your array (or convert your data to an array)
		    	
		    	for (String[] zeile : ergebnisList) {
		    		ergebnisWriter.writeNext(zeile);
				}
		    	ergebnisWriter.close();
		    	
		    	CSVWriter vereinWriter = new CSVWriter(new FileWriter(vereinFile), '#');
			     // feed in your array (or convert your data to an array)
		    	
		    	for (String[] zeile : vereinList) {
		    		vereinWriter.writeNext(zeile);
				}
		    	vereinWriter.close();
		    	
		    	CSVWriter wettkampfWriter = new CSVWriter(new FileWriter(wettkampfFile), '#');
			     // feed in your array (or convert your data to an array)
		    	
		    	for (String[] zeile : wettkampfList) {
		    		wettkampfWriter.writeNext(zeile);
				}
		    	wettkampfWriter.close();
		    	
		    }
		} catch (IOException e) {
		    Log.e(TAG, "Could not write file " + e.getMessage());
		}
		
	}
	
	/**
	 * Bis Android 1.6: Listener für Klick-Event auf Schaltfläche 'Karte
	 * Anzeigen'.
	 */
	private final OnClickListener mImportCSVListener = new OnClickListener() {
		public void onClick(View v) {
			KegelverwaltungCSVDatenbank csvDB = new KegelverwaltungCSVDatenbank(UtilitiesActivity.this);
			
			csvDB.resetAutoincrements();
			
			csvDB.erzeugeKlassenDaten(true);
			csvDB.erzeugeMannschaftDaten(true);
			csvDB.erzeugeSpielerDaten(true);
			csvDB.erzeugeVereinDaten(true);
			csvDB.erzeugeErgebnisDaten(true);
			csvDB.erzeugeWettkampfDaten(true);
			
			
		}
	};
	
	
	
	private void showDisplayProperties(){
		Display display = ((WindowManager) getSystemService(WINDOW_SERVICE)).getDefaultDisplay();
		
		/* Now we can retrieve all display-related infos */
		int width = display.getWidth();
		int height = display.getHeight();
		int orientation = display.getOrientation();
		LOG.v(TAG, String.valueOf(Math.sqrt(4)));
		Toast.makeText(this, "showDisplayProperties: width: " +width + " height: " +height + " orientation: "+orientation, Toast.LENGTH_LONG).show();
	}
	
	private void wifi(){
		WifiManager wifi = (WifiManager) getSystemService(Context.WIFI_SERVICE);
		wifi.setWifiEnabled(true);
	}
	
	private void alert(String title, String message){
		AlertDialog.Builder alert = new AlertDialog.Builder(this);
		alert.setTitle(title);
		alert.setMessage(message);

		// You can set an EditText view to get user input besides
		// which button was pressed.
		input = new EditText(this);
		alert.setView(input);

		alert.setPositiveButton("Ok", new DialogInterface.OnClickListener() {
		public void onClick(DialogInterface dialog, int whichButton) {
		  String value = input.getText().toString();
		  // Do something with value!
		  }
		});
		alert.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
		  public void onClick(DialogInterface dialog, int whichButton) {
		    // Canceled.
		  }
		});

		alert.show();
	}
	
	private void locate(){
		LocationManager locator = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
		LocationListener mLocationListener = new LocationListener() {
		  public void onLocationChanged(Location location) {
		    if (location != null) {
		      location.getAltitude();
		      location.getLatitude();
		      location.getLongitude();
		      location.getTime();
		      location.getAccuracy();
		      location.getSpeed();
		      location.getProvider();
		    }
		  }

		  public void onProviderDisabled(String provider) {
		    // ...
		  }

		  public void onProviderEnabled(String provider) {
		    // ...
		  }

		  public void onStatusChanged(String provider, int status, Bundle extras) {
		    // ...
		  }
		};

		// You need to specify a Criteria for picking the location data source.
		// The criteria can include power requirements.
		Criteria criteria = new Criteria();
		criteria.setAccuracy(Criteria.ACCURACY_COARSE);  // Faster, no GPS fix.
		criteria.setAccuracy(Criteria.ACCURACY_FINE);  // More accurate, GPS fix.
		
		// You can specify the time and distance between location updates.
		// Both are useful for reducing power requirements.
		mLocationManager.requestLocationUpdates(mLocationManager.getBestProvider(criteria, true),
		    MIN_LOCATION_UPDATE_TIME, MIN_LOCATION_UPDATE_DISTANCE, mLocationListener,
		    getMainLooper());
		
		// Start with fine location.
		Location l = locator.getLastKnownLocation(LocationManager.GPS_PROVIDER);
		if (l == null) {
		  // Fall back to coarse location.
		  l = locator.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
		}
	}
	
	private void sendSMS(){
		SmsManager m = SmsManager.getDefault();
		String destination = "8675309";
		String text = "Hello, Jenny!";
		m.sendTextMessage(destination, null, text, null, null);
	}
	
	private void vibrate(){
		((Vibrator) getSystemService(Context.VIBRATOR_SERVICE)).vibrate(3600);
	}
	
	private void sensor(){
		SensorManager mSensorManager = (SensorManager) getSystemService(Activity.SENSOR_SERVICE);
		final SensorListener mSensorListener = new SensorListener() {
		  public void onAccuracyChanged(int sensor, int accuracy) {
		    // ...
		  }

		  public void onSensorChanged(int sensor, float[] values) {
		    switch (sensor) {
		      case SensorManager.SENSOR_ORIENTATION:
		        float azimuth = values[0];
		        float pitch = values[1];
		        float roll = values[2];
		        break;
		      case SensorManager.SENSOR_ACCELEROMETER:
		        float xforce = values[0];
		        float yforce = values[1];
		        float zforce = values[2];
		        break;
		      case SensorManager.SENSOR_MAGNETIC_FIELD:
		        float xmag = values[0];
		        float ymag = values[1];
		        float zmag = values[2];
		        break;
		    }
		  }
		};

		// Start listening to all sensors.
		mSensorManager.registerListener(mSensorListener, mSensorManager.getSensors());
		// ...
		// Stop listening to sensors.
		mSensorManager.unregisterListener(mSensorListener);
	}
	
	private void silenceRinger(){
		mAudio = (AudioManager) getSystemService(Activity.AUDIO_SERVICE);
		mAudio.setRingerMode(AudioManager.RINGER_MODE_SILENT);
		// or...
		mAudio.setRingerMode(AudioManager.RINGER_MODE_NORMAL);
	}
	
	@Override
	protected void onStart() {
		super.onStart();
	}

	@Override
	protected void onResume() {
		LOG.v(TAG, "onResume");
		super.onResume();
	}
	
	@Override
	protected void onPause() {
		LOG.v(TAG, "onPause");
		super.onPause();
	}

	@Override
	protected void onStop() {
		LOG.v(TAG, "onStop");
		super.onStop();
	}
	
	@Override
	protected void onRestart() {
		LOG.v(TAG, "onRestart");
		super.onRestart();
	}

	@Override
	protected void onDestroy() {
		LOG.v(TAG, "onDestroy");
		super.onDestroy();
	}
	
	public void finishDB() {
		if(null != mKlasseSpeicher){
			mKlasseSpeicher.schliessen();
		}
		if(null != mMannschaftSpeicher){
			mMannschaftSpeicher.schliessen();
		}
		if(null != mSpielerSpeicher){
			mSpielerSpeicher.schliessen();
		}
		if(null != mErgebnisSpeicher){
			mErgebnisSpeicher.schliessen();
		}
		
		Intent data = new Intent();
		data.putExtra(INTENT_EXTRA_RESET_DB, 1);
		setResult(RESULT_OK, data);
		super.finish();
	}
}
